package cn.fx.framework.utils;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 快速生成泛型集合对象
 * @author Junhai, Liu
 * @version 1.0.0.1
 *
 */
public class New {

    /**
     * 生成HashMap
     */
    public static <K,V> Map<K,V> map(){
        return new HashMap<K,V>();
    }
    /**
     * 生成ConcurrentHashMap
     */
    public static <K,V> Map<K,V> cmap(){
        return new ConcurrentHashMap<K,V>();
    }
    /**
     * 生成HashMap，并将大小设为initSize
     */
    public static <K,V> Map<K,V> map(int initSize){
        return new HashMap<K,V>(initSize);
    }

    /**
     * 生成LinkedMap
     */
    public static <K,V> Map<K,V> lMap(){
        return new LinkedHashMap<K, V>();
    }
    /**
     * 生成LinkedMap，并将大小设为initSize
     */
    public static <K,V> Map<K,V> lMap(int initSize){
        return new LinkedHashMap<K, V>(initSize);
    }

    /**
     * 生成ArrayList
     */
    public static <T> List<T> list(){
        return new ArrayList<T>();
    }

    /**
     * 生成ArrayList，并将大小设为initSize
     */
    public static <T> List<T> list(int initSize){
        return new ArrayList<T>(initSize);
    }

    /**
     * 生成LinkedList
     */
    public static <T> LinkedList<T> lList(){
        return new LinkedList<T>();
    }

    /**
     * 生成HashSet
     */
    public static <T> Set<T> set(){
        return new HashSet<T>();
    }

    /**
     * 生成HashSet，并将大小设为initSize
     */
    public static <T> Set<T> set(int initSize){
        return new HashSet<T>(initSize);
    }

    /**
     * 生成有序的set集合
     * @param <T>
     * @return
     */
    public static <T> Set<T> lset(){
        return new LinkedHashSet<T>();
    }
    /**
     * 生成有序的set集合
     * @param <T>
     * @return
     */
    public static <T> Set<T> lset(int initSize){
        return new LinkedHashSet<T>(initSize);
    }

    /**
     * 生成Queue,其实也是LinkedList
     */
    public static <T> Queue<T> queue(){
        return new LinkedList<T>();
    }

    /**
     * 生成二元组对象
     * @return
     */
    public static <A,B> TwoTuple<A,B> tuple(A first, B second){
        return new TwoTuple<A,B>(first, second);
    }

    /**
     * 生成三元组对象
     */
    public static <A,B,C> ThreeTuple<A,B,C> tuple(A first, B second, C three){
        return new ThreeTuple<A,B,C>(first,second,three);
    }

    /**
     * 生成四元组对象
     */
    public static <A,B,C,D> FourTuple<A,B,C,D> tuple(A first, B second, C three, D fourth){
        return new FourTuple<A,B,C,D>(first, second, three, fourth);
    }
}
